// 《围棋》作者版权所有。保留所有权利。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

// go:build darwin | | freebsd | | linux 

package fuzz

import (
	"fmt"
	"os"
	"os/exec"
	"syscall"
)

type sharedMemSys struct{}

func sharedMemMapFile(f *os.File, size int, removeOnClose bool) (*sharedMem, error) {
	prot := syscall.PROT_READ | syscall.PROT_WRITE
	flags := syscall.MAP_FILE | syscall.MAP_SHARED
	region, err := syscall.Mmap(int(f.Fd()), 0, size, prot, flags)
	if err != nil {
		return nil, err
	}

	return &sharedMem{f: f, region: region, removeOnClose: removeOnClose}, nil
}

// Close取消映射共享内存并关闭临时文件。如果此
// sharedMem是使用sharedMemTempFile创建的，则Close还会删除该文件。
func (m *sharedMem) Close() error {
	// 尝试所有操作，即使之前的操作出现错误。
	// 操作系统。文件Close可能会因为I/O错误而失败，但我们仍然希望删除临时文件
	// 。
	var errs []error
	errs = append(errs,
		syscall.Munmap(m.region),
		m.f.Close())
	if m.removeOnClose {
		errs = append(errs, os.Remove(m.f.Name()))
	}
	for _, err := range errs {
		if err != nil {
			return err
		}
	}
	return nil
}

// setWorkerComm在cmd上配置通信通道，以运行工作进程。
func setWorkerComm(cmd *exec.Cmd, comm workerComm) {
	mem := <-comm.memMu
	memFile := mem.f
	comm.memMu <- mem
	cmd.ExtraFiles = []*os.File{comm.fuzzIn, comm.fuzzOut, memFile}
}

// GetWorkerCommand返回工作进程中的通信通道。
func getWorkerComm() (comm workerComm, err error) {
	fuzzIn := os.NewFile(3, "fuzz_in")
	fuzzOut := os.NewFile(4, "fuzz_out")
	memFile := os.NewFile(5, "fuzz_mem")
	fi, err := memFile.Stat()
	if err != nil {
		return workerComm{}, err
	}
	size := int(fi.Size())
	if int64(size) != fi.Size() {
		return workerComm{}, fmt.Errorf("fuzz temp file exceeds maximum size")
	}
	removeOnClose := false
	mem, err := sharedMemMapFile(memFile, size, removeOnClose)
	if err != nil {
		return workerComm{}, err
	}
	memMu := make(chan *sharedMem, 1)
	memMu <- mem
	return workerComm{fuzzIn: fuzzIn, fuzzOut: fuzzOut, memMu: memMu}, nil
}

// isInterruptError返回错误是否由中断信号（SIGINT）终止的进程返回。
func isInterruptError(err error) bool {
	exitErr, ok := err.(*exec.ExitError)
	if !ok || exitErr.ExitCode() >= 0 {
		return false
	}
	status := exitErr.Sys().(syscall.WaitStatus)
	return status.Signal() == syscall.SIGINT
}

// terminationSignal检查err是否为exec。显示一个信号状态。
// 如果是，terminationSignal返回信号并为true。
// 如果不是，-1，则为假。
func terminationSignal(err error) (os.Signal, bool) {
	exitErr, ok := err.(*exec.ExitError)
	if !ok || exitErr.ExitCode() >= 0 {
		return syscall.Signal(-1), false
	}
	status := exitErr.Sys().(syscall.WaitStatus)
	return status.Signal(), status.Signaled()
}

// isCrashSignal返回信号是否可能是由接收该信号的程序中的错误引起的，该错误由模糊输入触发。例如，对于
// 在零指针解引用后将接收到SIGSEGV。
// 其他信号，如SIGKILL或SIGHUP，更有可能是由另一个进程发送的，如果工作进程
// 收到其中一个信号，我们不应该记录崩溃。
// 
// 请注意，Go在启动时会安装自己的信号处理程序，因此，只有在信号处理程序发生更改时，才会接收其中一些
// 信号。例如，
// SIGSEGV通常会转化为恐慌，导致进程退出
// ，如果未恢复，状态为2，我们将其视为崩溃。
func isCrashSignal(signal os.Signal) bool {
	switch signal {
	case
		syscall.SIGILL,  // 非法指令
		syscall.SIGTRAP, // 断点
		syscall.SIGABRT, // abort（）调用
		syscall.SIGBUS,  // 内存访问无效（例如地址未对齐）
		syscall.SIGFPE,  // 数学错误，例如整数除以零
		syscall.SIGSEGV, // 内存访问无效（例如，写入只读）
		syscall.SIGPIPE: // 将数据发送到封闭管道或套接字
		return true
	default:
		return false
	}
}
